package com.runa.monitor.platinterface.dispatch.grpcComm;

import static io.grpc.MethodDescriptor.generateFullMethodName;
import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ClientCalls.asyncUnaryCall;
import static io.grpc.stub.ClientCalls.*;
import static io.grpc.stub.ServerCalls.*;
import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnaryCall;

/**
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.16.1)",
    comments = "Source: comm-server.proto")
public final class COMMDispatchGrpc {

  private COMMDispatchGrpc() {}

  public static final String SERVICE_NAME = "COMMDispatch";

  // Static method descriptors that strictly reflect the proto.
  private static volatile io.grpc.MethodDescriptor<NodeComm,
      EmptyComm> getLoginMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Login",
      requestType = NodeComm.class,
      responseType = EmptyComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<NodeComm,
      EmptyComm> getLoginMethod() {
    io.grpc.MethodDescriptor<NodeComm, EmptyComm> getLoginMethod;
    if ((getLoginMethod = COMMDispatchGrpc.getLoginMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getLoginMethod = COMMDispatchGrpc.getLoginMethod) == null) {
          COMMDispatchGrpc.getLoginMethod = getLoginMethod =
              io.grpc.MethodDescriptor.<NodeComm, EmptyComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "Login"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  NodeComm.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  EmptyComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("Login"))
                  .build();
          }
        }
     }
     return getLoginMethod;
  }

  private static volatile io.grpc.MethodDescriptor<ReadFmuNowVO,
      ResultComm> getReadFmuNowMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "readFmuNow",
      requestType = ReadFmuNowVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<ReadFmuNowVO,
      ResultComm> getReadFmuNowMethod() {
    io.grpc.MethodDescriptor<ReadFmuNowVO, ResultComm> getReadFmuNowMethod;
    if ((getReadFmuNowMethod = COMMDispatchGrpc.getReadFmuNowMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getReadFmuNowMethod = COMMDispatchGrpc.getReadFmuNowMethod) == null) {
          COMMDispatchGrpc.getReadFmuNowMethod = getReadFmuNowMethod =
              io.grpc.MethodDescriptor.<ReadFmuNowVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "readFmuNow"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ReadFmuNowVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("readFmuNow"))
                  .build();
          }
        }
     }
     return getReadFmuNowMethod;
  }

  private static volatile io.grpc.MethodDescriptor<SentEquArchiveVO,
      ResultComm> getSentEquArchiveMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "sentEquArchive",
      requestType = SentEquArchiveVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<SentEquArchiveVO,
      ResultComm> getSentEquArchiveMethod() {
    io.grpc.MethodDescriptor<SentEquArchiveVO, ResultComm> getSentEquArchiveMethod;
    if ((getSentEquArchiveMethod = COMMDispatchGrpc.getSentEquArchiveMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getSentEquArchiveMethod = COMMDispatchGrpc.getSentEquArchiveMethod) == null) {
          COMMDispatchGrpc.getSentEquArchiveMethod = getSentEquArchiveMethod =
              io.grpc.MethodDescriptor.<SentEquArchiveVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "sentEquArchive"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  SentEquArchiveVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("sentEquArchive"))
                  .build();
          }
        }
     }
     return getSentEquArchiveMethod;
  }

  private static volatile io.grpc.MethodDescriptor<ClearEquArchiveVO,
      ResultComm> getClearEquArchiveMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "clearEquArchive",
      requestType = ClearEquArchiveVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<ClearEquArchiveVO,
      ResultComm> getClearEquArchiveMethod() {
    io.grpc.MethodDescriptor<ClearEquArchiveVO, ResultComm> getClearEquArchiveMethod;
    if ((getClearEquArchiveMethod = COMMDispatchGrpc.getClearEquArchiveMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getClearEquArchiveMethod = COMMDispatchGrpc.getClearEquArchiveMethod) == null) {
          COMMDispatchGrpc.getClearEquArchiveMethod = getClearEquArchiveMethod =
              io.grpc.MethodDescriptor.<ClearEquArchiveVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "clearEquArchive"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ClearEquArchiveVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("clearEquArchive"))
                  .build();
          }
        }
     }
     return getClearEquArchiveMethod;
  }

  private static volatile io.grpc.MethodDescriptor<ReadEquArchiveVO,
      ResultComm> getReadEquArchiveMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "readEquArchive",
      requestType = ReadEquArchiveVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<ReadEquArchiveVO,
      ResultComm> getReadEquArchiveMethod() {
    io.grpc.MethodDescriptor<ReadEquArchiveVO, ResultComm> getReadEquArchiveMethod;
    if ((getReadEquArchiveMethod = COMMDispatchGrpc.getReadEquArchiveMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getReadEquArchiveMethod = COMMDispatchGrpc.getReadEquArchiveMethod) == null) {
          COMMDispatchGrpc.getReadEquArchiveMethod = getReadEquArchiveMethod =
              io.grpc.MethodDescriptor.<ReadEquArchiveVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "readEquArchive"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ReadEquArchiveVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("readEquArchive"))
                  .build();
          }
        }
     }
     return getReadEquArchiveMethod;
  }

  private static volatile io.grpc.MethodDescriptor<SetMeterReadingCycleParameterVO,
      ResultComm> getSetMeterReadingCycleParameterMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "setMeterReadingCycleParameter",
      requestType = SetMeterReadingCycleParameterVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<SetMeterReadingCycleParameterVO,
      ResultComm> getSetMeterReadingCycleParameterMethod() {
    io.grpc.MethodDescriptor<SetMeterReadingCycleParameterVO, ResultComm> getSetMeterReadingCycleParameterMethod;
    if ((getSetMeterReadingCycleParameterMethod = COMMDispatchGrpc.getSetMeterReadingCycleParameterMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getSetMeterReadingCycleParameterMethod = COMMDispatchGrpc.getSetMeterReadingCycleParameterMethod) == null) {
          COMMDispatchGrpc.getSetMeterReadingCycleParameterMethod = getSetMeterReadingCycleParameterMethod =
              io.grpc.MethodDescriptor.<SetMeterReadingCycleParameterVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "setMeterReadingCycleParameter"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  SetMeterReadingCycleParameterVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("setMeterReadingCycleParameter"))
                  .build();
          }
        }
     }
     return getSetMeterReadingCycleParameterMethod;
  }

  private static volatile io.grpc.MethodDescriptor<ReadMeterReadingCycleParameterVO,
      ResultComm> getReadMeterReadingCycleParameterMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "readMeterReadingCycleParameter",
      requestType = ReadMeterReadingCycleParameterVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<ReadMeterReadingCycleParameterVO,
      ResultComm> getReadMeterReadingCycleParameterMethod() {
    io.grpc.MethodDescriptor<ReadMeterReadingCycleParameterVO, ResultComm> getReadMeterReadingCycleParameterMethod;
    if ((getReadMeterReadingCycleParameterMethod = COMMDispatchGrpc.getReadMeterReadingCycleParameterMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getReadMeterReadingCycleParameterMethod = COMMDispatchGrpc.getReadMeterReadingCycleParameterMethod) == null) {
          COMMDispatchGrpc.getReadMeterReadingCycleParameterMethod = getReadMeterReadingCycleParameterMethod =
              io.grpc.MethodDescriptor.<ReadMeterReadingCycleParameterVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "readMeterReadingCycleParameter"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ReadMeterReadingCycleParameterVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("readMeterReadingCycleParameter"))
                  .build();
          }
        }
     }
     return getReadMeterReadingCycleParameterMethod;
  }

  private static volatile io.grpc.MethodDescriptor<SetFlowLimitVO,
      ResultComm> getSetFlowLimitMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "setFlowLimit",
      requestType = SetFlowLimitVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<SetFlowLimitVO,
      ResultComm> getSetFlowLimitMethod() {
    io.grpc.MethodDescriptor<SetFlowLimitVO, ResultComm> getSetFlowLimitMethod;
    if ((getSetFlowLimitMethod = COMMDispatchGrpc.getSetFlowLimitMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getSetFlowLimitMethod = COMMDispatchGrpc.getSetFlowLimitMethod) == null) {
          COMMDispatchGrpc.getSetFlowLimitMethod = getSetFlowLimitMethod =
              io.grpc.MethodDescriptor.<SetFlowLimitVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "setFlowLimit"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  SetFlowLimitVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("setFlowLimit"))
                  .build();
          }
        }
     }
     return getSetFlowLimitMethod;
  }

  private static volatile io.grpc.MethodDescriptor<ReadMeterVO,
      ResultComm> getReadMeterMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "readMeter",
      requestType = ReadMeterVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<ReadMeterVO,
      ResultComm> getReadMeterMethod() {
    io.grpc.MethodDescriptor<ReadMeterVO, ResultComm> getReadMeterMethod;
    if ((getReadMeterMethod = COMMDispatchGrpc.getReadMeterMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getReadMeterMethod = COMMDispatchGrpc.getReadMeterMethod) == null) {
          COMMDispatchGrpc.getReadMeterMethod = getReadMeterMethod =
              io.grpc.MethodDescriptor.<ReadMeterVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "readMeter"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ReadMeterVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("readMeter"))
                  .build();
          }
        }
     }
     return getReadMeterMethod;
  }

  private static volatile io.grpc.MethodDescriptor<ReadElecMeterVO,
      ResultComm> getReadElecMeterMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "readElecMeter",
      requestType = ReadElecMeterVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<ReadElecMeterVO,
      ResultComm> getReadElecMeterMethod() {
    io.grpc.MethodDescriptor<ReadElecMeterVO, ResultComm> getReadElecMeterMethod;
    if ((getReadElecMeterMethod = COMMDispatchGrpc.getReadElecMeterMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getReadElecMeterMethod = COMMDispatchGrpc.getReadElecMeterMethod) == null) {
          COMMDispatchGrpc.getReadElecMeterMethod = getReadElecMeterMethod =
              io.grpc.MethodDescriptor.<ReadElecMeterVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "readElecMeter"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ReadElecMeterVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("readElecMeter"))
                  .build();
          }
        }
     }
     return getReadElecMeterMethod;
  }

  private static volatile io.grpc.MethodDescriptor<ReadValveVO,
      ResultComm> getReadValveMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "readValve",
      requestType = ReadValveVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<ReadValveVO,
      ResultComm> getReadValveMethod() {
    io.grpc.MethodDescriptor<ReadValveVO, ResultComm> getReadValveMethod;
    if ((getReadValveMethod = COMMDispatchGrpc.getReadValveMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getReadValveMethod = COMMDispatchGrpc.getReadValveMethod) == null) {
          COMMDispatchGrpc.getReadValveMethod = getReadValveMethod =
              io.grpc.MethodDescriptor.<ReadValveVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "readValve"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ReadValveVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("readValve"))
                  .build();
          }
        }
     }
     return getReadValveMethod;
  }

  private static volatile io.grpc.MethodDescriptor<ReadPanelVO,
      ResultComm> getReadPanelMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "readPanel",
      requestType = ReadPanelVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<ReadPanelVO,
      ResultComm> getReadPanelMethod() {
    io.grpc.MethodDescriptor<ReadPanelVO, ResultComm> getReadPanelMethod;
    if ((getReadPanelMethod = COMMDispatchGrpc.getReadPanelMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getReadPanelMethod = COMMDispatchGrpc.getReadPanelMethod) == null) {
          COMMDispatchGrpc.getReadPanelMethod = getReadPanelMethod =
              io.grpc.MethodDescriptor.<ReadPanelVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "readPanel"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ReadPanelVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("readPanel"))
                  .build();
          }
        }
     }
     return getReadPanelMethod;
  }

  private static volatile io.grpc.MethodDescriptor<BuildValveParamVO,
      ResultComm> getBuildValveParamMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "buildValveParam",
      requestType = BuildValveParamVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<BuildValveParamVO,
      ResultComm> getBuildValveParamMethod() {
    io.grpc.MethodDescriptor<BuildValveParamVO, ResultComm> getBuildValveParamMethod;
    if ((getBuildValveParamMethod = COMMDispatchGrpc.getBuildValveParamMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getBuildValveParamMethod = COMMDispatchGrpc.getBuildValveParamMethod) == null) {
          COMMDispatchGrpc.getBuildValveParamMethod = getBuildValveParamMethod =
              io.grpc.MethodDescriptor.<BuildValveParamVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "buildValveParam"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  BuildValveParamVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("buildValveParam"))
                  .build();
          }
        }
     }
     return getBuildValveParamMethod;
  }

  private static volatile io.grpc.MethodDescriptor<BuildValveControlVO,
      ResultComm> getBuildValveControlMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "buildValveControl",
      requestType = BuildValveControlVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<BuildValveControlVO,
      ResultComm> getBuildValveControlMethod() {
    io.grpc.MethodDescriptor<BuildValveControlVO, ResultComm> getBuildValveControlMethod;
    if ((getBuildValveControlMethod = COMMDispatchGrpc.getBuildValveControlMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getBuildValveControlMethod = COMMDispatchGrpc.getBuildValveControlMethod) == null) {
          COMMDispatchGrpc.getBuildValveControlMethod = getBuildValveControlMethod =
              io.grpc.MethodDescriptor.<BuildValveControlVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "buildValveControl"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  BuildValveControlVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("buildValveControl"))
                  .build();
          }
        }
     }
     return getBuildValveControlMethod;
  }

  private static volatile io.grpc.MethodDescriptor<BuildValveControlOfOpenVO,
      ResultComm> getBuildValveControlOfOpenMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "buildValveControlOfOpen",
      requestType = BuildValveControlOfOpenVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<BuildValveControlOfOpenVO,
      ResultComm> getBuildValveControlOfOpenMethod() {
    io.grpc.MethodDescriptor<BuildValveControlOfOpenVO, ResultComm> getBuildValveControlOfOpenMethod;
    if ((getBuildValveControlOfOpenMethod = COMMDispatchGrpc.getBuildValveControlOfOpenMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getBuildValveControlOfOpenMethod = COMMDispatchGrpc.getBuildValveControlOfOpenMethod) == null) {
          COMMDispatchGrpc.getBuildValveControlOfOpenMethod = getBuildValveControlOfOpenMethod =
              io.grpc.MethodDescriptor.<BuildValveControlOfOpenVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "buildValveControlOfOpen"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  BuildValveControlOfOpenVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("buildValveControlOfOpen"))
                  .build();
          }
        }
     }
     return getBuildValveControlOfOpenMethod;
  }

  private static volatile io.grpc.MethodDescriptor<ValveTemperatureControlVO,
      ResultComm> getValveTemperatureControlMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "valveTemperatureControl",
      requestType = ValveTemperatureControlVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<ValveTemperatureControlVO,
      ResultComm> getValveTemperatureControlMethod() {
    io.grpc.MethodDescriptor<ValveTemperatureControlVO, ResultComm> getValveTemperatureControlMethod;
    if ((getValveTemperatureControlMethod = COMMDispatchGrpc.getValveTemperatureControlMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getValveTemperatureControlMethod = COMMDispatchGrpc.getValveTemperatureControlMethod) == null) {
          COMMDispatchGrpc.getValveTemperatureControlMethod = getValveTemperatureControlMethod =
              io.grpc.MethodDescriptor.<ValveTemperatureControlVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "valveTemperatureControl"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ValveTemperatureControlVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("valveTemperatureControl"))
                  .build();
          }
        }
     }
     return getValveTemperatureControlMethod;
  }

  private static volatile io.grpc.MethodDescriptor<ValveTemperatureCompVO,
      ResultComm> getValveTemperatureCompMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "valveTemperatureComp",
      requestType = ValveTemperatureCompVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<ValveTemperatureCompVO,
      ResultComm> getValveTemperatureCompMethod() {
    io.grpc.MethodDescriptor<ValveTemperatureCompVO, ResultComm> getValveTemperatureCompMethod;
    if ((getValveTemperatureCompMethod = COMMDispatchGrpc.getValveTemperatureCompMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getValveTemperatureCompMethod = COMMDispatchGrpc.getValveTemperatureCompMethod) == null) {
          COMMDispatchGrpc.getValveTemperatureCompMethod = getValveTemperatureCompMethod =
              io.grpc.MethodDescriptor.<ValveTemperatureCompVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "valveTemperatureComp"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ValveTemperatureCompVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("valveTemperatureComp"))
                  .build();
          }
        }
     }
     return getValveTemperatureCompMethod;
  }

  private static volatile io.grpc.MethodDescriptor<BuildValveModelVO,
      ResultComm> getBuildValveModelMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "buildValveModel",
      requestType = BuildValveModelVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<BuildValveModelVO,
      ResultComm> getBuildValveModelMethod() {
    io.grpc.MethodDescriptor<BuildValveModelVO, ResultComm> getBuildValveModelMethod;
    if ((getBuildValveModelMethod = COMMDispatchGrpc.getBuildValveModelMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getBuildValveModelMethod = COMMDispatchGrpc.getBuildValveModelMethod) == null) {
          COMMDispatchGrpc.getBuildValveModelMethod = getBuildValveModelMethod =
              io.grpc.MethodDescriptor.<BuildValveModelVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "buildValveModel"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  BuildValveModelVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("buildValveModel"))
                  .build();
          }
        }
     }
     return getBuildValveModelMethod;
  }

  private static volatile io.grpc.MethodDescriptor<BuildValveModelOfTimeSchemeVO,
      ResultComm> getBuildValveModelOfTimeSchemeMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "buildValveModelOfTimeScheme",
      requestType = BuildValveModelOfTimeSchemeVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<BuildValveModelOfTimeSchemeVO,
      ResultComm> getBuildValveModelOfTimeSchemeMethod() {
    io.grpc.MethodDescriptor<BuildValveModelOfTimeSchemeVO, ResultComm> getBuildValveModelOfTimeSchemeMethod;
    if ((getBuildValveModelOfTimeSchemeMethod = COMMDispatchGrpc.getBuildValveModelOfTimeSchemeMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getBuildValveModelOfTimeSchemeMethod = COMMDispatchGrpc.getBuildValveModelOfTimeSchemeMethod) == null) {
          COMMDispatchGrpc.getBuildValveModelOfTimeSchemeMethod = getBuildValveModelOfTimeSchemeMethod =
              io.grpc.MethodDescriptor.<BuildValveModelOfTimeSchemeVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "buildValveModelOfTimeScheme"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  BuildValveModelOfTimeSchemeVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("buildValveModelOfTimeScheme"))
                  .build();
          }
        }
     }
     return getBuildValveModelOfTimeSchemeMethod;
  }

  private static volatile io.grpc.MethodDescriptor<BuildValveModelOfPIDVO,
      ResultComm> getBuildValveModelOfPIDMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "buildValveModelOfPID",
      requestType = BuildValveModelOfPIDVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<BuildValveModelOfPIDVO,
      ResultComm> getBuildValveModelOfPIDMethod() {
    io.grpc.MethodDescriptor<BuildValveModelOfPIDVO, ResultComm> getBuildValveModelOfPIDMethod;
    if ((getBuildValveModelOfPIDMethod = COMMDispatchGrpc.getBuildValveModelOfPIDMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getBuildValveModelOfPIDMethod = COMMDispatchGrpc.getBuildValveModelOfPIDMethod) == null) {
          COMMDispatchGrpc.getBuildValveModelOfPIDMethod = getBuildValveModelOfPIDMethod =
              io.grpc.MethodDescriptor.<BuildValveModelOfPIDVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "buildValveModelOfPID"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  BuildValveModelOfPIDVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("buildValveModelOfPID"))
                  .build();
          }
        }
     }
     return getBuildValveModelOfPIDMethod;
  }

  private static volatile io.grpc.MethodDescriptor<FlowUnitComm,
      FlowUnitComm> getInteractionFlowMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "InteractionFlow",
      requestType = FlowUnitComm.class,
      responseType = FlowUnitComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
  public static io.grpc.MethodDescriptor<FlowUnitComm,
      FlowUnitComm> getInteractionFlowMethod() {
    io.grpc.MethodDescriptor<FlowUnitComm, FlowUnitComm> getInteractionFlowMethod;
    if ((getInteractionFlowMethod = COMMDispatchGrpc.getInteractionFlowMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getInteractionFlowMethod = COMMDispatchGrpc.getInteractionFlowMethod) == null) {
          COMMDispatchGrpc.getInteractionFlowMethod = getInteractionFlowMethod =
              io.grpc.MethodDescriptor.<FlowUnitComm, FlowUnitComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "InteractionFlow"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  FlowUnitComm.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  FlowUnitComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("InteractionFlow"))
                  .build();
          }
        }
     }
     return getInteractionFlowMethod;
  }

  private static volatile io.grpc.MethodDescriptor<AiDownloadFileVO,
      ResultComm> getAiDownloadFileMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "aiDownloadFile",
      requestType = AiDownloadFileVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<AiDownloadFileVO,
      ResultComm> getAiDownloadFileMethod() {
    io.grpc.MethodDescriptor<AiDownloadFileVO, ResultComm> getAiDownloadFileMethod;
    if ((getAiDownloadFileMethod = COMMDispatchGrpc.getAiDownloadFileMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getAiDownloadFileMethod = COMMDispatchGrpc.getAiDownloadFileMethod) == null) {
          COMMDispatchGrpc.getAiDownloadFileMethod = getAiDownloadFileMethod =
              io.grpc.MethodDescriptor.<AiDownloadFileVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "aiDownloadFile"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  AiDownloadFileVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("aiDownloadFile"))
                  .build();
          }
        }
     }
     return getAiDownloadFileMethod;
  }

  private static volatile io.grpc.MethodDescriptor<ValveTemperatureControlOfAiStormVO,
      ResultComm> getValveTemperatureControlOfAiStormMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "valveTemperatureControlOfAiStorm",
      requestType = ValveTemperatureControlOfAiStormVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<ValveTemperatureControlOfAiStormVO,
      ResultComm> getValveTemperatureControlOfAiStormMethod() {
    io.grpc.MethodDescriptor<ValveTemperatureControlOfAiStormVO, ResultComm> getValveTemperatureControlOfAiStormMethod;
    if ((getValveTemperatureControlOfAiStormMethod = COMMDispatchGrpc.getValveTemperatureControlOfAiStormMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getValveTemperatureControlOfAiStormMethod = COMMDispatchGrpc.getValveTemperatureControlOfAiStormMethod) == null) {
          COMMDispatchGrpc.getValveTemperatureControlOfAiStormMethod = getValveTemperatureControlOfAiStormMethod =
              io.grpc.MethodDescriptor.<ValveTemperatureControlOfAiStormVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "valveTemperatureControlOfAiStorm"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ValveTemperatureControlOfAiStormVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("valveTemperatureControlOfAiStorm"))
                  .build();
          }
        }
     }
     return getValveTemperatureControlOfAiStormMethod;
  }

  private static volatile io.grpc.MethodDescriptor<UniversalVO,
      ResultComm> getUniversalCallMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "universalCall",
      requestType = UniversalVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<UniversalVO,
      ResultComm> getUniversalCallMethod() {
    io.grpc.MethodDescriptor<UniversalVO, ResultComm> getUniversalCallMethod;
    if ((getUniversalCallMethod = COMMDispatchGrpc.getUniversalCallMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getUniversalCallMethod = COMMDispatchGrpc.getUniversalCallMethod) == null) {
          COMMDispatchGrpc.getUniversalCallMethod = getUniversalCallMethod =
              io.grpc.MethodDescriptor.<UniversalVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "universalCall"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  UniversalVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("universalCall"))
                  .build();
          }
        }
     }
     return getUniversalCallMethod;
  }

  private static volatile io.grpc.MethodDescriptor<SendDxVO,
      ResultComm> getSendDxMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "sendDx",
      requestType = SendDxVO.class,
      responseType = ResultComm.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<SendDxVO,
      ResultComm> getSendDxMethod() {
    io.grpc.MethodDescriptor<SendDxVO, ResultComm> getSendDxMethod;
    if ((getSendDxMethod = COMMDispatchGrpc.getSendDxMethod) == null) {
      synchronized (COMMDispatchGrpc.class) {
        if ((getSendDxMethod = COMMDispatchGrpc.getSendDxMethod) == null) {
          COMMDispatchGrpc.getSendDxMethod = getSendDxMethod =
              io.grpc.MethodDescriptor.<SendDxVO, ResultComm>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(
                  "COMMDispatch", "sendDx"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  SendDxVO.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  ResultComm.getDefaultInstance()))
                  .setSchemaDescriptor(new COMMDispatchMethodDescriptorSupplier("sendDx"))
                  .build();
          }
        }
     }
     return getSendDxMethod;
  }

  /**
   * Creates a new async stub that supports all call types for the service
   */
  public static COMMDispatchStub newStub(io.grpc.Channel channel) {
    return new COMMDispatchStub(channel);
  }

  /**
   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
   */
  public static COMMDispatchBlockingStub newBlockingStub(
      io.grpc.Channel channel) {
    return new COMMDispatchBlockingStub(channel);
  }

  /**
   * Creates a new ListenableFuture-style stub that supports unary calls on the service
   */
  public static COMMDispatchFutureStub newFutureStub(
      io.grpc.Channel channel) {
    return new COMMDispatchFutureStub(channel);
  }

  /**
   */
  public static abstract class COMMDispatchImplBase implements io.grpc.BindableService {

    /**
     */
    public void login(NodeComm request,
                      io.grpc.stub.StreamObserver<EmptyComm> responseObserver) {
      asyncUnimplementedUnaryCall(getLoginMethod(), responseObserver);
    }

    /**
     */
    public void readFmuNow(ReadFmuNowVO request,
                           io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getReadFmuNowMethod(), responseObserver);
    }

    /**
     */
    public void sentEquArchive(SentEquArchiveVO request,
                               io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getSentEquArchiveMethod(), responseObserver);
    }

    /**
     */
    public void clearEquArchive(ClearEquArchiveVO request,
                                io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getClearEquArchiveMethod(), responseObserver);
    }

    /**
     */
    public void readEquArchive(ReadEquArchiveVO request,
                               io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getReadEquArchiveMethod(), responseObserver);
    }

    /**
     */
    public void setMeterReadingCycleParameter(SetMeterReadingCycleParameterVO request,
                                              io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getSetMeterReadingCycleParameterMethod(), responseObserver);
    }

    /**
     */
    public void readMeterReadingCycleParameter(ReadMeterReadingCycleParameterVO request,
                                               io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getReadMeterReadingCycleParameterMethod(), responseObserver);
    }

    /**
     */
    public void setFlowLimit(SetFlowLimitVO request,
                             io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getSetFlowLimitMethod(), responseObserver);
    }

    /**
     */
    public void readMeter(ReadMeterVO request,
                          io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getReadMeterMethod(), responseObserver);
    }

    /**
     */
    public void readElecMeter(ReadElecMeterVO request,
                              io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getReadElecMeterMethod(), responseObserver);
    }

    /**
     */
    public void readValve(ReadValveVO request,
                          io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getReadValveMethod(), responseObserver);
    }

    /**
     */
    public void readPanel(ReadPanelVO request,
                          io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getReadPanelMethod(), responseObserver);
    }

    /**
     */
    public void buildValveParam(BuildValveParamVO request,
                                io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getBuildValveParamMethod(), responseObserver);
    }

    /**
     */
    public void buildValveControl(BuildValveControlVO request,
                                  io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getBuildValveControlMethod(), responseObserver);
    }

    /**
     */
    public void buildValveControlOfOpen(BuildValveControlOfOpenVO request,
                                        io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getBuildValveControlOfOpenMethod(), responseObserver);
    }

    /**
     */
    public void valveTemperatureControl(ValveTemperatureControlVO request,
                                        io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getValveTemperatureControlMethod(), responseObserver);
    }

    /**
     */
    public void valveTemperatureComp(ValveTemperatureCompVO request,
                                     io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getValveTemperatureCompMethod(), responseObserver);
    }

    /**
     */
    public void buildValveModel(BuildValveModelVO request,
                                io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getBuildValveModelMethod(), responseObserver);
    }

    /**
     */
    public void buildValveModelOfTimeScheme(BuildValveModelOfTimeSchemeVO request,
                                            io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getBuildValveModelOfTimeSchemeMethod(), responseObserver);
    }

    /**
     */
    public void buildValveModelOfPID(BuildValveModelOfPIDVO request,
                                     io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getBuildValveModelOfPIDMethod(), responseObserver);
    }

    /**
     */
    public io.grpc.stub.StreamObserver<FlowUnitComm> interactionFlow(
        io.grpc.stub.StreamObserver<FlowUnitComm> responseObserver) {
      return asyncUnimplementedStreamingCall(getInteractionFlowMethod(), responseObserver);
    }

    /**
     */
    public void aiDownloadFile(AiDownloadFileVO request,
                               io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getAiDownloadFileMethod(), responseObserver);
    }

    /**
     */
    public void valveTemperatureControlOfAiStorm(ValveTemperatureControlOfAiStormVO request,
                                                 io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getValveTemperatureControlOfAiStormMethod(), responseObserver);
    }

    /**
     */
    public void universalCall(UniversalVO request,
                              io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getUniversalCallMethod(), responseObserver);
    }

    /**
     */
    public void sendDx(SendDxVO request,
                       io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnimplementedUnaryCall(getSendDxMethod(), responseObserver);
    }

    @Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            getLoginMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                NodeComm,
                EmptyComm>(
                  this, METHODID_LOGIN)))
          .addMethod(
            getReadFmuNowMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                ReadFmuNowVO,
                ResultComm>(
                  this, METHODID_READ_FMU_NOW)))
          .addMethod(
            getSentEquArchiveMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                SentEquArchiveVO,
                ResultComm>(
                  this, METHODID_SENT_EQU_ARCHIVE)))
          .addMethod(
            getClearEquArchiveMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                ClearEquArchiveVO,
                ResultComm>(
                  this, METHODID_CLEAR_EQU_ARCHIVE)))
          .addMethod(
            getReadEquArchiveMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                ReadEquArchiveVO,
                ResultComm>(
                  this, METHODID_READ_EQU_ARCHIVE)))
          .addMethod(
            getSetMeterReadingCycleParameterMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                SetMeterReadingCycleParameterVO,
                ResultComm>(
                  this, METHODID_SET_METER_READING_CYCLE_PARAMETER)))
          .addMethod(
            getReadMeterReadingCycleParameterMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                ReadMeterReadingCycleParameterVO,
                ResultComm>(
                  this, METHODID_READ_METER_READING_CYCLE_PARAMETER)))
          .addMethod(
            getSetFlowLimitMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                SetFlowLimitVO,
                ResultComm>(
                  this, METHODID_SET_FLOW_LIMIT)))
          .addMethod(
            getReadMeterMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                ReadMeterVO,
                ResultComm>(
                  this, METHODID_READ_METER)))
          .addMethod(
            getReadElecMeterMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                ReadElecMeterVO,
                ResultComm>(
                  this, METHODID_READ_ELEC_METER)))
          .addMethod(
            getReadValveMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                ReadValveVO,
                ResultComm>(
                  this, METHODID_READ_VALVE)))
          .addMethod(
            getReadPanelMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                ReadPanelVO,
                ResultComm>(
                  this, METHODID_READ_PANEL)))
          .addMethod(
            getBuildValveParamMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                BuildValveParamVO,
                ResultComm>(
                  this, METHODID_BUILD_VALVE_PARAM)))
          .addMethod(
            getBuildValveControlMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                BuildValveControlVO,
                ResultComm>(
                  this, METHODID_BUILD_VALVE_CONTROL)))
          .addMethod(
            getBuildValveControlOfOpenMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                BuildValveControlOfOpenVO,
                ResultComm>(
                  this, METHODID_BUILD_VALVE_CONTROL_OF_OPEN)))
          .addMethod(
            getValveTemperatureControlMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                ValveTemperatureControlVO,
                ResultComm>(
                  this, METHODID_VALVE_TEMPERATURE_CONTROL)))
          .addMethod(
            getValveTemperatureCompMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                ValveTemperatureCompVO,
                ResultComm>(
                  this, METHODID_VALVE_TEMPERATURE_COMP)))
          .addMethod(
            getBuildValveModelMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                BuildValveModelVO,
                ResultComm>(
                  this, METHODID_BUILD_VALVE_MODEL)))
          .addMethod(
            getBuildValveModelOfTimeSchemeMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                BuildValveModelOfTimeSchemeVO,
                ResultComm>(
                  this, METHODID_BUILD_VALVE_MODEL_OF_TIME_SCHEME)))
          .addMethod(
            getBuildValveModelOfPIDMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                BuildValveModelOfPIDVO,
                ResultComm>(
                  this, METHODID_BUILD_VALVE_MODEL_OF_PID)))
          .addMethod(
            getInteractionFlowMethod(),
            asyncBidiStreamingCall(
              new MethodHandlers<
                FlowUnitComm,
                FlowUnitComm>(
                  this, METHODID_INTERACTION_FLOW)))
          .addMethod(
            getAiDownloadFileMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                AiDownloadFileVO,
                ResultComm>(
                  this, METHODID_AI_DOWNLOAD_FILE)))
          .addMethod(
            getValveTemperatureControlOfAiStormMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                ValveTemperatureControlOfAiStormVO,
                ResultComm>(
                  this, METHODID_VALVE_TEMPERATURE_CONTROL_OF_AI_STORM)))
          .addMethod(
            getUniversalCallMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                UniversalVO,
                ResultComm>(
                  this, METHODID_UNIVERSAL_CALL)))
          .addMethod(
            getSendDxMethod(),
            asyncUnaryCall(
              new MethodHandlers<
                SendDxVO,
                ResultComm>(
                  this, METHODID_SEND_DX)))
          .build();
    }
  }

  /**
   */
  public static final class COMMDispatchStub extends io.grpc.stub.AbstractStub<COMMDispatchStub> {
    private COMMDispatchStub(io.grpc.Channel channel) {
      super(channel);
    }

    private COMMDispatchStub(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @Override
    protected COMMDispatchStub build(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      return new COMMDispatchStub(channel, callOptions);
    }

    /**
     */
    public void login(NodeComm request,
                      io.grpc.stub.StreamObserver<EmptyComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getLoginMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void readFmuNow(ReadFmuNowVO request,
                           io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getReadFmuNowMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void sentEquArchive(SentEquArchiveVO request,
                               io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getSentEquArchiveMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void clearEquArchive(ClearEquArchiveVO request,
                                io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getClearEquArchiveMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void readEquArchive(ReadEquArchiveVO request,
                               io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getReadEquArchiveMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void setMeterReadingCycleParameter(SetMeterReadingCycleParameterVO request,
                                              io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getSetMeterReadingCycleParameterMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void readMeterReadingCycleParameter(ReadMeterReadingCycleParameterVO request,
                                               io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getReadMeterReadingCycleParameterMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void setFlowLimit(SetFlowLimitVO request,
                             io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getSetFlowLimitMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void readMeter(ReadMeterVO request,
                          io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getReadMeterMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void readElecMeter(ReadElecMeterVO request,
                              io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getReadElecMeterMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void readValve(ReadValveVO request,
                          io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getReadValveMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void readPanel(ReadPanelVO request,
                          io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getReadPanelMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void buildValveParam(BuildValveParamVO request,
                                io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getBuildValveParamMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void buildValveControl(BuildValveControlVO request,
                                  io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getBuildValveControlMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void buildValveControlOfOpen(BuildValveControlOfOpenVO request,
                                        io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getBuildValveControlOfOpenMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void valveTemperatureControl(ValveTemperatureControlVO request,
                                        io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getValveTemperatureControlMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void valveTemperatureComp(ValveTemperatureCompVO request,
                                     io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getValveTemperatureCompMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void buildValveModel(BuildValveModelVO request,
                                io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getBuildValveModelMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void buildValveModelOfTimeScheme(BuildValveModelOfTimeSchemeVO request,
                                            io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getBuildValveModelOfTimeSchemeMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void buildValveModelOfPID(BuildValveModelOfPIDVO request,
                                     io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getBuildValveModelOfPIDMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public io.grpc.stub.StreamObserver<FlowUnitComm> interactionFlow(
        io.grpc.stub.StreamObserver<FlowUnitComm> responseObserver) {
      return asyncBidiStreamingCall(
          getChannel().newCall(getInteractionFlowMethod(), getCallOptions()), responseObserver);
    }

    /**
     */
    public void aiDownloadFile(AiDownloadFileVO request,
                               io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getAiDownloadFileMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void valveTemperatureControlOfAiStorm(ValveTemperatureControlOfAiStormVO request,
                                                 io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getValveTemperatureControlOfAiStormMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void universalCall(UniversalVO request,
                              io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getUniversalCallMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void sendDx(SendDxVO request,
                       io.grpc.stub.StreamObserver<ResultComm> responseObserver) {
      asyncUnaryCall(
          getChannel().newCall(getSendDxMethod(), getCallOptions()), request, responseObserver);
    }
  }

  /**
   */
  public static final class COMMDispatchBlockingStub extends io.grpc.stub.AbstractStub<COMMDispatchBlockingStub> {
    private COMMDispatchBlockingStub(io.grpc.Channel channel) {
      super(channel);
    }

    private COMMDispatchBlockingStub(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @Override
    protected COMMDispatchBlockingStub build(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      return new COMMDispatchBlockingStub(channel, callOptions);
    }

    /**
     */
    public EmptyComm login(NodeComm request) {
      return blockingUnaryCall(
          getChannel(), getLoginMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm readFmuNow(ReadFmuNowVO request) {
      return blockingUnaryCall(
          getChannel(), getReadFmuNowMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm sentEquArchive(SentEquArchiveVO request) {
      return blockingUnaryCall(
          getChannel(), getSentEquArchiveMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm clearEquArchive(ClearEquArchiveVO request) {
      return blockingUnaryCall(
          getChannel(), getClearEquArchiveMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm readEquArchive(ReadEquArchiveVO request) {
      return blockingUnaryCall(
          getChannel(), getReadEquArchiveMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm setMeterReadingCycleParameter(SetMeterReadingCycleParameterVO request) {
      return blockingUnaryCall(
          getChannel(), getSetMeterReadingCycleParameterMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm readMeterReadingCycleParameter(ReadMeterReadingCycleParameterVO request) {
      return blockingUnaryCall(
          getChannel(), getReadMeterReadingCycleParameterMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm setFlowLimit(SetFlowLimitVO request) {
      return blockingUnaryCall(
          getChannel(), getSetFlowLimitMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm readMeter(ReadMeterVO request) {
      return blockingUnaryCall(
          getChannel(), getReadMeterMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm readElecMeter(ReadElecMeterVO request) {
      return blockingUnaryCall(
          getChannel(), getReadElecMeterMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm readValve(ReadValveVO request) {
      return blockingUnaryCall(
          getChannel(), getReadValveMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm readPanel(ReadPanelVO request) {
      return blockingUnaryCall(
          getChannel(), getReadPanelMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm buildValveParam(BuildValveParamVO request) {
      return blockingUnaryCall(
          getChannel(), getBuildValveParamMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm buildValveControl(BuildValveControlVO request) {
      return blockingUnaryCall(
          getChannel(), getBuildValveControlMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm buildValveControlOfOpen(BuildValveControlOfOpenVO request) {
      return blockingUnaryCall(
          getChannel(), getBuildValveControlOfOpenMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm valveTemperatureControl(ValveTemperatureControlVO request) {
      return blockingUnaryCall(
          getChannel(), getValveTemperatureControlMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm valveTemperatureComp(ValveTemperatureCompVO request) {
      return blockingUnaryCall(
          getChannel(), getValveTemperatureCompMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm buildValveModel(BuildValveModelVO request) {
      return blockingUnaryCall(
          getChannel(), getBuildValveModelMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm buildValveModelOfTimeScheme(BuildValveModelOfTimeSchemeVO request) {
      return blockingUnaryCall(
          getChannel(), getBuildValveModelOfTimeSchemeMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm buildValveModelOfPID(BuildValveModelOfPIDVO request) {
      return blockingUnaryCall(
          getChannel(), getBuildValveModelOfPIDMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm aiDownloadFile(AiDownloadFileVO request) {
      return blockingUnaryCall(
          getChannel(), getAiDownloadFileMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm valveTemperatureControlOfAiStorm(ValveTemperatureControlOfAiStormVO request) {
      return blockingUnaryCall(
          getChannel(), getValveTemperatureControlOfAiStormMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm universalCall(UniversalVO request) {
      return blockingUnaryCall(
          getChannel(), getUniversalCallMethod(), getCallOptions(), request);
    }

    /**
     */
    public ResultComm sendDx(SendDxVO request) {
      return blockingUnaryCall(
          getChannel(), getSendDxMethod(), getCallOptions(), request);
    }
  }

  /**
   */
  public static final class COMMDispatchFutureStub extends io.grpc.stub.AbstractStub<COMMDispatchFutureStub> {
    private COMMDispatchFutureStub(io.grpc.Channel channel) {
      super(channel);
    }

    private COMMDispatchFutureStub(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @Override
    protected COMMDispatchFutureStub build(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      return new COMMDispatchFutureStub(channel, callOptions);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<EmptyComm> login(
        NodeComm request) {
      return futureUnaryCall(
          getChannel().newCall(getLoginMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> readFmuNow(
        ReadFmuNowVO request) {
      return futureUnaryCall(
          getChannel().newCall(getReadFmuNowMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> sentEquArchive(
        SentEquArchiveVO request) {
      return futureUnaryCall(
          getChannel().newCall(getSentEquArchiveMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> clearEquArchive(
        ClearEquArchiveVO request) {
      return futureUnaryCall(
          getChannel().newCall(getClearEquArchiveMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> readEquArchive(
        ReadEquArchiveVO request) {
      return futureUnaryCall(
          getChannel().newCall(getReadEquArchiveMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> setMeterReadingCycleParameter(
        SetMeterReadingCycleParameterVO request) {
      return futureUnaryCall(
          getChannel().newCall(getSetMeterReadingCycleParameterMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> readMeterReadingCycleParameter(
        ReadMeterReadingCycleParameterVO request) {
      return futureUnaryCall(
          getChannel().newCall(getReadMeterReadingCycleParameterMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> setFlowLimit(
        SetFlowLimitVO request) {
      return futureUnaryCall(
          getChannel().newCall(getSetFlowLimitMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> readMeter(
        ReadMeterVO request) {
      return futureUnaryCall(
          getChannel().newCall(getReadMeterMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> readElecMeter(
        ReadElecMeterVO request) {
      return futureUnaryCall(
          getChannel().newCall(getReadElecMeterMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> readValve(
        ReadValveVO request) {
      return futureUnaryCall(
          getChannel().newCall(getReadValveMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> readPanel(
        ReadPanelVO request) {
      return futureUnaryCall(
          getChannel().newCall(getReadPanelMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> buildValveParam(
        BuildValveParamVO request) {
      return futureUnaryCall(
          getChannel().newCall(getBuildValveParamMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> buildValveControl(
        BuildValveControlVO request) {
      return futureUnaryCall(
          getChannel().newCall(getBuildValveControlMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> buildValveControlOfOpen(
        BuildValveControlOfOpenVO request) {
      return futureUnaryCall(
          getChannel().newCall(getBuildValveControlOfOpenMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> valveTemperatureControl(
        ValveTemperatureControlVO request) {
      return futureUnaryCall(
          getChannel().newCall(getValveTemperatureControlMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> valveTemperatureComp(
        ValveTemperatureCompVO request) {
      return futureUnaryCall(
          getChannel().newCall(getValveTemperatureCompMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> buildValveModel(
        BuildValveModelVO request) {
      return futureUnaryCall(
          getChannel().newCall(getBuildValveModelMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> buildValveModelOfTimeScheme(
        BuildValveModelOfTimeSchemeVO request) {
      return futureUnaryCall(
          getChannel().newCall(getBuildValveModelOfTimeSchemeMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> buildValveModelOfPID(
        BuildValveModelOfPIDVO request) {
      return futureUnaryCall(
          getChannel().newCall(getBuildValveModelOfPIDMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> aiDownloadFile(
        AiDownloadFileVO request) {
      return futureUnaryCall(
          getChannel().newCall(getAiDownloadFileMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> valveTemperatureControlOfAiStorm(
        ValveTemperatureControlOfAiStormVO request) {
      return futureUnaryCall(
          getChannel().newCall(getValveTemperatureControlOfAiStormMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> universalCall(
        UniversalVO request) {
      return futureUnaryCall(
          getChannel().newCall(getUniversalCallMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<ResultComm> sendDx(
        SendDxVO request) {
      return futureUnaryCall(
          getChannel().newCall(getSendDxMethod(), getCallOptions()), request);
    }
  }

  private static final int METHODID_LOGIN = 0;
  private static final int METHODID_READ_FMU_NOW = 1;
  private static final int METHODID_SENT_EQU_ARCHIVE = 2;
  private static final int METHODID_CLEAR_EQU_ARCHIVE = 3;
  private static final int METHODID_READ_EQU_ARCHIVE = 4;
  private static final int METHODID_SET_METER_READING_CYCLE_PARAMETER = 5;
  private static final int METHODID_READ_METER_READING_CYCLE_PARAMETER = 6;
  private static final int METHODID_SET_FLOW_LIMIT = 7;
  private static final int METHODID_READ_METER = 8;
  private static final int METHODID_READ_ELEC_METER = 9;
  private static final int METHODID_READ_VALVE = 10;
  private static final int METHODID_READ_PANEL = 11;
  private static final int METHODID_BUILD_VALVE_PARAM = 12;
  private static final int METHODID_BUILD_VALVE_CONTROL = 13;
  private static final int METHODID_BUILD_VALVE_CONTROL_OF_OPEN = 14;
  private static final int METHODID_VALVE_TEMPERATURE_CONTROL = 15;
  private static final int METHODID_VALVE_TEMPERATURE_COMP = 16;
  private static final int METHODID_BUILD_VALVE_MODEL = 17;
  private static final int METHODID_BUILD_VALVE_MODEL_OF_TIME_SCHEME = 18;
  private static final int METHODID_BUILD_VALVE_MODEL_OF_PID = 19;
  private static final int METHODID_AI_DOWNLOAD_FILE = 20;
  private static final int METHODID_VALVE_TEMPERATURE_CONTROL_OF_AI_STORM = 21;
  private static final int METHODID_UNIVERSAL_CALL = 22;
  private static final int METHODID_SEND_DX = 23;
  private static final int METHODID_INTERACTION_FLOW = 24;

  private static final class MethodHandlers<Req, Resp> implements
      UnaryMethod<Req, Resp>,
      ServerStreamingMethod<Req, Resp>,
      ClientStreamingMethod<Req, Resp>,
      BidiStreamingMethod<Req, Resp> {
    private final COMMDispatchImplBase serviceImpl;
    private final int methodId;

    MethodHandlers(COMMDispatchImplBase serviceImpl, int methodId) {
      this.serviceImpl = serviceImpl;
      this.methodId = methodId;
    }

    @Override
    @SuppressWarnings("unchecked")
    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        case METHODID_LOGIN:
          serviceImpl.login((NodeComm) request,
              (io.grpc.stub.StreamObserver<EmptyComm>) responseObserver);
          break;
        case METHODID_READ_FMU_NOW:
          serviceImpl.readFmuNow((ReadFmuNowVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_SENT_EQU_ARCHIVE:
          serviceImpl.sentEquArchive((SentEquArchiveVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_CLEAR_EQU_ARCHIVE:
          serviceImpl.clearEquArchive((ClearEquArchiveVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_READ_EQU_ARCHIVE:
          serviceImpl.readEquArchive((ReadEquArchiveVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_SET_METER_READING_CYCLE_PARAMETER:
          serviceImpl.setMeterReadingCycleParameter((SetMeterReadingCycleParameterVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_READ_METER_READING_CYCLE_PARAMETER:
          serviceImpl.readMeterReadingCycleParameter((ReadMeterReadingCycleParameterVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_SET_FLOW_LIMIT:
          serviceImpl.setFlowLimit((SetFlowLimitVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_READ_METER:
          serviceImpl.readMeter((ReadMeterVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_READ_ELEC_METER:
          serviceImpl.readElecMeter((ReadElecMeterVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_READ_VALVE:
          serviceImpl.readValve((ReadValveVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_READ_PANEL:
          serviceImpl.readPanel((ReadPanelVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_BUILD_VALVE_PARAM:
          serviceImpl.buildValveParam((BuildValveParamVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_BUILD_VALVE_CONTROL:
          serviceImpl.buildValveControl((BuildValveControlVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_BUILD_VALVE_CONTROL_OF_OPEN:
          serviceImpl.buildValveControlOfOpen((BuildValveControlOfOpenVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_VALVE_TEMPERATURE_CONTROL:
          serviceImpl.valveTemperatureControl((ValveTemperatureControlVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_VALVE_TEMPERATURE_COMP:
          serviceImpl.valveTemperatureComp((ValveTemperatureCompVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_BUILD_VALVE_MODEL:
          serviceImpl.buildValveModel((BuildValveModelVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_BUILD_VALVE_MODEL_OF_TIME_SCHEME:
          serviceImpl.buildValveModelOfTimeScheme((BuildValveModelOfTimeSchemeVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_BUILD_VALVE_MODEL_OF_PID:
          serviceImpl.buildValveModelOfPID((BuildValveModelOfPIDVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_AI_DOWNLOAD_FILE:
          serviceImpl.aiDownloadFile((AiDownloadFileVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_VALVE_TEMPERATURE_CONTROL_OF_AI_STORM:
          serviceImpl.valveTemperatureControlOfAiStorm((ValveTemperatureControlOfAiStormVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_UNIVERSAL_CALL:
          serviceImpl.universalCall((UniversalVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        case METHODID_SEND_DX:
          serviceImpl.sendDx((SendDxVO) request,
              (io.grpc.stub.StreamObserver<ResultComm>) responseObserver);
          break;
        default:
          throw new AssertionError();
      }
    }

    @Override
    @SuppressWarnings("unchecked")
    public io.grpc.stub.StreamObserver<Req> invoke(
        io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        case METHODID_INTERACTION_FLOW:
          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.interactionFlow(
              (io.grpc.stub.StreamObserver<FlowUnitComm>) responseObserver);
        default:
          throw new AssertionError();
      }
    }
  }

  private static abstract class COMMDispatchBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    COMMDispatchBaseDescriptorSupplier() {}

    @Override
    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
      return CommServer.getDescriptor();
    }

    @Override
    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
      return getFileDescriptor().findServiceByName("COMMDispatch");
    }
  }

  private static final class COMMDispatchFileDescriptorSupplier
      extends COMMDispatchBaseDescriptorSupplier {
    COMMDispatchFileDescriptorSupplier() {}
  }

  private static final class COMMDispatchMethodDescriptorSupplier
      extends COMMDispatchBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    COMMDispatchMethodDescriptorSupplier(String methodName) {
      this.methodName = methodName;
    }

    @Override
    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
      return getServiceDescriptor().findMethodByName(methodName);
    }
  }

  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;

  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
    io.grpc.ServiceDescriptor result = serviceDescriptor;
    if (result == null) {
      synchronized (COMMDispatchGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new COMMDispatchFileDescriptorSupplier())
              .addMethod(getLoginMethod())
              .addMethod(getReadFmuNowMethod())
              .addMethod(getSentEquArchiveMethod())
              .addMethod(getClearEquArchiveMethod())
              .addMethod(getReadEquArchiveMethod())
              .addMethod(getSetMeterReadingCycleParameterMethod())
              .addMethod(getReadMeterReadingCycleParameterMethod())
              .addMethod(getSetFlowLimitMethod())
              .addMethod(getReadMeterMethod())
              .addMethod(getReadElecMeterMethod())
              .addMethod(getReadValveMethod())
              .addMethod(getReadPanelMethod())
              .addMethod(getBuildValveParamMethod())
              .addMethod(getBuildValveControlMethod())
              .addMethod(getBuildValveControlOfOpenMethod())
              .addMethod(getValveTemperatureControlMethod())
              .addMethod(getValveTemperatureCompMethod())
              .addMethod(getBuildValveModelMethod())
              .addMethod(getBuildValveModelOfTimeSchemeMethod())
              .addMethod(getBuildValveModelOfPIDMethod())
              .addMethod(getInteractionFlowMethod())
              .addMethod(getAiDownloadFileMethod())
              .addMethod(getValveTemperatureControlOfAiStormMethod())
              .addMethod(getUniversalCallMethod())
              .addMethod(getSendDxMethod())
              .build();
        }
      }
    }
    return result;
  }
}
